package com.heima.datastructure.array;

import org.jctools.queues.MessagePassingQueue;

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

public class DynamicArray implements Iterable<Integer> {
    private int size = 0; //逻辑大小
    private int capacity = 10; //容量大小
    private int[] array = {};

    /**
     * 向最后位置[size]添加元素
     *
     * @param element 待添加的元素
     */
    public void addLast(int element) {
        add(size, element);
    }

    /**
     * 向指定索引位置添加元素
     *
     * @param index   指定的索引位置
     * @param element 添加的元素
     */
    public void add(int index, int element) {
        checkAndGrow();
        //添加逻辑
        if (index >= 0 && index < size) {
            System.arraycopy(array, index, array, index + 1, size - index);
        }
        array[index] = element;
        size++;
    }

    /**
     * 容量检查和扩容
     */
    private void checkAndGrow() {
        //容量检查
        if (size == 0){
           array = new int[capacity];
        }else if (size == capacity){
            //进行扩容 1.5 1.618 2
            capacity += capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array,0,newArray,0,size);
            array = newArray;
        }
    }

    /**
     * 删除指定元素
     * @param index 删除元素的索引
     * @return 删除元素的值
     */
    public int remove(int index) {  //[0-size-1]
        int removed = array[index];
        if (index < size - 1) {
            System.arraycopy(array, index + 1, array, index, size - 1 - index);
            size--;
        }
        return removed;
    }

    /**
     * 查询元素
     *
     * @param index 索引位置
     * @return 该索引位置的元素
     */
    public int get(int index) {
        return array[index];
    }

    /**
     * 遍历方法1
     *
     * @param consumer 遍历要执行的操作，需要给consumer提供入参
     */
    public void foreach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

    /**
     * 遍历方法2 迭代器遍历
     *
     * @return 返回一个迭代器
     */
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<>() {
            int i = 0;

            @Override
            public boolean hasNext() { //有没有下一个元素
                return i < size;
            }

            @Override
            public Integer next() { //返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    /**
     * 遍历方法3 stream流遍历
     *
     * @return 返回一个stream流
     */
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));  //含头不含尾
    }
}
